{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "node_vector [1. 1. 2. 1. 0. 0. 0. 0. 0.]\n",
      "adjacency_matrix\n",
      "[[0. 1. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [1. 0. 1. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 1. 0. 1. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 1. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0.]]\n",
      "CCOC\n",
      "010110010000000000010000000000000001000000000000010000000000000000000000000000000000000000\n",
      "node_vector [1. 1. 2. 1. 0. 0. 0. 0. 0.]\n",
      "adjacency_matrix\n",
      "[[0. 1. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [1. 0. 1. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 1. 0. 1. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 1. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0.]]\n",
      "CCOC\n"
     ]
    }
   ],
   "source": [
    "from rdkit import Chem\n",
    "import numpy as np\n",
    "import itertools\n",
    "import multiprocessing\n",
    "import pandas as pd\n",
    "\n",
    "def subfunction_generate_state(cls, node_vector, adjacency_matrix, new_index):\n",
    "    \"\"\"Wrapper function for the use of multiprocessing. \"\"\"\n",
    "    new_node_vector, new_adjacency_matrix = cls.permutate_connectivity(node_vector, adjacency_matrix, new_index)\n",
    "    new_quantum_state = cls.ConnectivityToQuantumState(new_node_vector, new_adjacency_matrix)\n",
    "    return new_quantum_state\n",
    "\n",
    "class MoleculeQuantumStateGenerator():\n",
    "    def __init__(self, heavy_atom_size=5, ncpus=4, sanitize_method=\"strict\", stereo_chiral=True):\n",
    "        self.size = heavy_atom_size\n",
    "        self.effective_numbers = list(range(heavy_atom_size))\n",
    "        self.ncpus = ncpus\n",
    "        self.atom_type_to_idx = {\"C\": 1, \"O\":2, \"N\": 3} # only supports C, O, N atoms now.\n",
    "        self.bond_type_to_idx = {Chem.rdchem.BondType.SINGLE: 1, Chem.rdchem.BondType.DOUBLE: 2, Chem.rdchem.BondType.TRIPLE: 3}\n",
    "        self.idx_to_atom_type = {1: \"C\", 2: \"O\", 3: \"N\"}\n",
    "        self.idx_to_bond_type = {1: Chem.rdchem.BondType.SINGLE, 2: Chem.rdchem.BondType.DOUBLE, 3: Chem.rdchem.BondType.TRIPLE}\n",
    "        self.qubits_per_type_atom = int(np.ceil(np.log2(len(self.atom_type_to_idx) + 1))) # How many qubits required for describing the quantum state of atom type\n",
    "        self.qubits_per_type_bond = int(np.ceil(np.log2(len(self.bond_type_to_idx) + 1))) # How many qubits required for describing the quantum state of bond type\n",
    "        self.n_qubits = int(self.size * self.qubits_per_type_atom + self.size * (self.size-1) / 2 * self.qubits_per_type_bond)\n",
    "        self.sanitize_method = sanitize_method\n",
    "        self.atom_valence_dict = {\"C\":4, \"N\":3, \"O\":2}\n",
    "        self.stereo_chiral = stereo_chiral\n",
    "\n",
    "    def decimal_to_binary(self, x, padding_length=2):\n",
    "        \"\"\"\n",
    "        Parameters:\n",
    "        x (int): The decimal value.\n",
    "\n",
    "        Returns:\n",
    "        str: A binary bit string.\n",
    "        \"\"\"\n",
    "        bit = \"0\"*(padding_length-1) + bin(x)[2:]\n",
    "        return bit[-padding_length:] # -2 means we only take 4 possible states\n",
    "\n",
    "    def SmilesToConnectivity(self, smiles):\n",
    "        \"\"\"\n",
    "        Generate a molecular graph from a SMILES string.\n",
    "\n",
    "        Parameters:\n",
    "        smiles (str): The SMILES string representing the molecule.\n",
    "\n",
    "        Returns:\n",
    "        tuple: A tuple containing the node vector (np.ndarray) and the adjacency matrix (np.ndarray).\n",
    "        \"\"\"\n",
    "        node_vector = np.zeros(self.size)\n",
    "        adjacency_matrix = np.zeros((self.size, self.size))\n",
    "        mol = Chem.MolFromSmiles(smiles)\n",
    "        Chem.Kekulize(mol)\n",
    "        for atom in mol.GetAtoms():\n",
    "            idx = atom.GetIdx()\n",
    "            atom_type = atom.GetSymbol()\n",
    "            node_vector[idx] = self.atom_type_to_idx[atom_type]\n",
    "        for bond in mol.GetBonds():\n",
    "            i = bond.GetBeginAtomIdx()\n",
    "            j = bond.GetEndAtomIdx()\n",
    "            adjacency_matrix[i][j] = self.bond_type_to_idx[bond.GetBondType()]\n",
    "            adjacency_matrix[j][i] = self.bond_type_to_idx[bond.GetBondType()]\n",
    "        return node_vector, adjacency_matrix\n",
    "\n",
    "    def _rank_list(self, lst):\n",
    "        sorted_list = sorted(enumerate(lst), key=lambda x: x[1])\n",
    "        rank = [0] * len(lst)\n",
    "        for i, (original_index, _) in enumerate(sorted_list):\n",
    "            rank[original_index] = i + 1\n",
    "        return rank\n",
    "\n",
    "    def _can_sort_with_even_swaps(self, list1, list2):\n",
    "        def count_inversions(lst):\n",
    "            inversions = 0\n",
    "            for i in range(len(lst)):\n",
    "                for j in range(i + 1, len(lst)):\n",
    "                    if lst[i] > lst[j]:\n",
    "                        inversions += 1\n",
    "            return inversions\n",
    "        inversions_list1 = count_inversions(list1)\n",
    "        inversions_list2 = count_inversions(list2)\n",
    "        return (inversions_list1 - inversions_list2) % 2 == 0\n",
    "\n",
    "    def _set_chiral_atom(self, mol):\n",
    "        for atom in mol.GetAtoms():\n",
    "            if atom.GetPropsAsDict(True, False).get(\"_ChiralityPossible\", 0):\n",
    "                atom_map_list = [int(neighbor.GetProp('molAtomMapNumber')) for neighbor in atom.GetNeighbors()]\n",
    "                CIP_list = [int(neighbor.GetProp('_CIPRank')) for neighbor in atom.GetNeighbors()]\n",
    "                chiral_tag = self._can_sort_with_even_swaps(self._rank_list(atom_map_list), self._rank_list(CIP_list))\n",
    "                if chiral_tag:\n",
    "                    atom.SetChiralTag(Chem.rdchem.ChiralType.CHI_TETRAHEDRAL_CW)\n",
    "                else:\n",
    "                    atom.SetChiralTag(Chem.rdchem.ChiralType.CHI_TETRAHEDRAL_CCW)\n",
    "\n",
    "    def _determine_bond_stereo(self, bond):\n",
    "        begin_atom = bond.GetBeginAtom()\n",
    "        begin_atom_map_number = int(begin_atom.GetProp('molAtomMapNumber'))\n",
    "        end_atom = bond.GetEndAtom()\n",
    "        end_atom_map_number = int(end_atom.GetProp('molAtomMapNumber'))\n",
    "        begin_atom_neighbor_map = [int(a.GetProp('molAtomMapNumber')) for a in begin_atom.GetNeighbors()]\n",
    "        begin_atom_neighbor_map.remove(end_atom_map_number)\n",
    "        print(begin_atom_neighbor_map)\n",
    "        end_atom_neighbor_map = [int(a.GetProp('molAtomMapNumber')) for a in end_atom.GetNeighbors()]\n",
    "        end_atom_neighbor_map.remove(begin_atom_map_number)\n",
    "        print(end_atom_neighbor_map)\n",
    "        if (len(begin_atom_neighbor_map) == 1) and (len(end_atom_neighbor_map) == 1):\n",
    "            if abs(begin_atom_neighbor_map[0] - begin_atom_map_number) == abs(end_atom_neighbor_map[0] - end_atom_map_number):\n",
    "                bond.SetStereo(Chem.rdchem.BondStereo.STEREOZ)\n",
    "            else:\n",
    "                bond.SetStereo(Chem.rdchem.BondStereo.STEREOE)\n",
    "        else:\n",
    "            begin_CIP_list = [int(neighbor.GetProp('_CIPRank')) for neighbor in begin_atom.GetNeighbors() \n",
    "                            if int(neighbor.GetProp('molAtomMapNumber')) != end_atom_map_number]\n",
    "            print(begin_CIP_list)\n",
    "            end_CIP_list = [int(neighbor.GetProp('_CIPRank')) for neighbor in end_atom.GetNeighbors()\n",
    "                            if int(neighbor.GetProp('molAtomMapNumber')) != begin_atom_map_number]\n",
    "            print(end_CIP_list)\n",
    "            if self._can_sort_with_even_swaps(self._rank_list(begin_atom_neighbor_map), self._rank_list(begin_CIP_list)) == \\\n",
    "                self._can_sort_with_even_swaps(self._rank_list(end_atom_neighbor_map), self._rank_list(end_CIP_list)):\n",
    "                bond.SetStereo(Chem.rdchem.BondStereo.STEREOZ)\n",
    "            else:\n",
    "                bond.SetStereo(Chem.rdchem.BondStereo.STEREOE)\n",
    "        return\n",
    "\n",
    "    def _set_stereo_bond(self, mol):\n",
    "        Chem.FindPotentialStereoBonds(mol,cleanIt=True)\n",
    "        for bond in mol.GetBonds():\n",
    "            if bond.GetStereo() == Chem.rdchem.BondStereo.STEREOANY:\n",
    "                self._determine_bond_stereo(bond)\n",
    "        return\n",
    "\n",
    "    def ConnectivityToSmiles(self, node_vector, adjacency_matrix, assign_stereo=True, keep_atom_map=False):\n",
    "        \"\"\"\n",
    "        Generate a SMILES string from the molecular graph.\n",
    "\n",
    "        Returns:\n",
    "        str: The SMILES string representing the molecule.\n",
    "        \"\"\"\n",
    "        mol = Chem.RWMol()\n",
    "        mapping_num_2_molIdx = {}\n",
    "        for i, atom_type_idx in enumerate(node_vector):\n",
    "            if atom_type_idx == 0:\n",
    "                continue\n",
    "            a = Chem.Atom(self.idx_to_atom_type[atom_type_idx])\n",
    "            a.SetAtomMapNum(i+1)\n",
    "            molIdx = mol.AddAtom(a)\n",
    "            mapping_num_2_molIdx.update({i: molIdx})\n",
    "        # add bonds between adjacent atoms, only traverse half the matrix\n",
    "        for ix, row in enumerate(adjacency_matrix):\n",
    "            for iy_, bond_type_idx in enumerate(row[ix+1:]):\n",
    "                iy = ix + iy_ + 1\n",
    "                if bond_type_idx == 0:\n",
    "                    continue\n",
    "                else:\n",
    "                    bond_type = self.idx_to_bond_type[bond_type_idx]\n",
    "                    try:\n",
    "                        mol.AddBond(mapping_num_2_molIdx[ix], mapping_num_2_molIdx[iy], bond_type)\n",
    "                    except:\n",
    "                        return None\n",
    "        mol = mol.GetMol()\n",
    "        if self.sanitize_method == \"strict\":\n",
    "            try:\n",
    "                Chem.SanitizeMol(mol)\n",
    "            except:\n",
    "                return None\n",
    "        elif self.sanitize_method == \"soft\":\n",
    "            try:\n",
    "                Chem.SanitizeMol(mol)\n",
    "            except:\n",
    "                try:\n",
    "                    for atom in mol.GetAtoms():\n",
    "                        bond_count = int(sum([bond.GetBondTypeAsDouble() for bond in atom.GetBonds()]))\n",
    "                        if atom.GetSymbol() == \"O\" and bond_count >= 3:\n",
    "                            atom.SetFormalCharge(bond_count - 2)\n",
    "                        elif atom.GetSymbol() == \"N\" and bond_count >= 4:\n",
    "                            atom.SetFormalCharge(bond_count - 3)\n",
    "                        elif atom.GetSymbol() == \"c\" and bond_count >= 5:\n",
    "                            atom.SetFormalCharge(bond_count - 4)\n",
    "                    Chem.SanitizeMol(mol)\n",
    "                except:\n",
    "                    return None\n",
    "        if assign_stereo:\n",
    "            Chem.AssignStereochemistry(mol, flagPossibleStereoCenters=True)\n",
    "            if self.stereo_chiral:\n",
    "                self._set_chiral_atom(mol)\n",
    "                self._set_stereo_bond(mol)\n",
    "        if not keep_atom_map:\n",
    "            for atom in mol.GetAtoms():\n",
    "                atom.SetAtomMapNum(0)\n",
    "        return Chem.MolToSmiles(mol, canonical=True)\n",
    "\n",
    "    def ConnectivityToQuantumState(self, node_vector, adjacency_matrix):\n",
    "        \"\"\"\n",
    "        Generate the quantum state (bit vector) based on the molecular connectivity.\n",
    "        The preceding bits represent the atom type, and the subsequent bits represent the connectivity.\n",
    "        \n",
    "        Returns:\n",
    "        np.ndarray: computational quantum state.\n",
    "        \"\"\"\n",
    "        quantum_state = \"\"\n",
    "        for atom_idx in node_vector:\n",
    "            quantum_state += self.decimal_to_binary(int(atom_idx), padding_length=self.qubits_per_type_atom)\n",
    "        for ix, row in enumerate(adjacency_matrix):\n",
    "            for bond_type_idx in row[ix+1:]:\n",
    "                quantum_state += self.decimal_to_binary(int(bond_type_idx), padding_length=self.qubits_per_type_bond)\n",
    "        return quantum_state\n",
    "\n",
    "    def QuantumStateToConnectivity(self, quantum_state):\n",
    "        node_state = quantum_state[:2*self.size]\n",
    "        bond_state = quantum_state[2*self.size:]\n",
    "        node_vector = np.zeros(self.size)\n",
    "        adjacency_matrix = np.zeros((self.size, self.size))\n",
    "        for i in range(0, len(node_state), 2):\n",
    "            node_vector[i//2] = int(node_state[i:i+2], 2)\n",
    "        row = 0\n",
    "        for i in range(0, len(bond_state), 2):\n",
    "            idx = i // 2\n",
    "            if idx == (2*(self.size-1) - (row+1) + 1) * (row+1) / 2:\n",
    "                row += 1\n",
    "            column = int(idx - (2*(self.size-1) - row + 1) * row / 2) + row + 1\n",
    "            bond_type_idx = int(bond_state[i:i+2], 2)\n",
    "            adjacency_matrix[row][column] = bond_type_idx\n",
    "            adjacency_matrix[column][row] = bond_type_idx\n",
    "        return node_vector, adjacency_matrix\n",
    "    \n",
    "    def QuantumStateToSmiles(self, quantum_state):\n",
    "        return self.ConnectivityToSmiles(*self.QuantumStateToConnectivity(quantum_state))\n",
    "    \n",
    "    def QuantumStateToStateVector(self, quantum_state):\n",
    "        stat_vector = np.zeros(2**self.n_qubits)\n",
    "        decimal = int(quantum_state, 2)\n",
    "        stat_vector[-1-decimal] = 1\n",
    "        return stat_vector\n",
    "    \n",
    "    def QuantumStateToDecimal(self, quantum_state):\n",
    "        decimal = int(quantum_state, 2)\n",
    "        return decimal\n",
    "    \n",
    "    def post_process_quantum_state(self, result_state: str):\n",
    "        \"\"\"\n",
    "        Reverse the qiskit outcome state and change the order to meet the definition of node vector and adjacency matrix.\n",
    "\n",
    "        :param result_state: computational state derived from qiskit measurement outcomes\n",
    "        :return: str of post-processed quantum state\n",
    "        \"\"\"\n",
    "        assert len(result_state) == self.size*(self.size+1)\n",
    "        result_state = result_state[::-1]\n",
    "        quantum_state = \"\"\n",
    "        for i in range(self.size):\n",
    "            atom_start_idx = i*2 + i*(i-1)\n",
    "            quantum_state += result_state[atom_start_idx:atom_start_idx+2]\n",
    "        for i in range(1, self.size):\n",
    "            for a_k, j in enumerate(range(i, self.size)):\n",
    "                bond_start_idx = (i+1)*2 + 2*a_k + j*(j-1) + (i-1)*2\n",
    "                quantum_state += result_state[bond_start_idx:bond_start_idx+2]\n",
    "        return quantum_state\n",
    "\n",
    "    def generate_permutations(self, k):\n",
    "        \"\"\"\n",
    "        Generate all possible permutations of k elements from the given list of elements.\n",
    "\n",
    "        :param k: Number of elements to choose for permutations\n",
    "        :return: List of permutations\n",
    "        \"\"\"\n",
    "        return list(itertools.permutations(self.effective_numbers, k))\n",
    "    \n",
    "    def enumerate_all_quantum_states(self, smiles):\n",
    "        \"\"\"\n",
    "        Generate all possible quantum states representing the given molecule SMILES.\n",
    "\n",
    "        :return: List of quantum states (str)\n",
    "        \"\"\"\n",
    "        node_vector, adjacency_matrix = self.SmilesToConnectivity(smiles)\n",
    "        all_permutation_index = self.generate_permutations(np.count_nonzero(node_vector))\n",
    "        args = [(self, node_vector, adjacency_matrix, new_index) for new_index in all_permutation_index]\n",
    "        with multiprocessing.Pool(processes=self.ncpus) as pool:\n",
    "            all_quantum_states = pool.starmap(subfunction_generate_state, args)\n",
    "\n",
    "        return list(set(all_quantum_states))\n",
    "\n",
    "    def permutate_connectivity(self, node_vector, adjacency_matrix, new_index):\n",
    "        mapping_dict = {old: new for old, new in enumerate(new_index)}\n",
    "        new_node_vector = np.zeros(self.size)\n",
    "        new_adjacency_matrix = np.zeros((self.size, self.size))\n",
    "        # atom\n",
    "        for old, new in mapping_dict.items():\n",
    "            new_node_vector[new] = node_vector[old]\n",
    "        # bond\n",
    "        for ix, row in enumerate(adjacency_matrix):\n",
    "            for iy_, bond_type_idx in enumerate(row[ix+1:]):\n",
    "                if not bond_type_idx:\n",
    "                    continue\n",
    "                iy = ix + iy_ + 1\n",
    "                ix_new = mapping_dict[ix]\n",
    "                iy_new = mapping_dict[iy]\n",
    "                new_adjacency_matrix[ix_new][iy_new] = bond_type_idx\n",
    "                new_adjacency_matrix[iy_new][ix_new] = bond_type_idx\n",
    "        return new_node_vector, new_adjacency_matrix\n",
    "\n",
    "    def generate_valid_mask(self, data: pd.DataFrame):\n",
    "        \"\"\"\n",
    "        :return: binary valid quantum states mask (np.ndarray)\n",
    "        \"\"\"\n",
    "        valid_state_vector_mask = np.zeros(2**self.n_qubits)\n",
    "        for decimal_index in set(data[\"decimal_index\"]):\n",
    "            valid_state_vector_mask[int(decimal_index)] = 1\n",
    "        return valid_state_vector_mask\n",
    "\n",
    "smiles = \"CCOC\"\n",
    "QG = MoleculeQuantumStateGenerator(9)\n",
    "node_vector, adjacency_matrix = QG.SmilesToConnectivity(smiles)\n",
    "print(\"node_vector\", node_vector)\n",
    "print(\"adjacency_matrix\")\n",
    "print(adjacency_matrix)\n",
    "print(QG.ConnectivityToSmiles(node_vector, adjacency_matrix))\n",
    "quantum_state = QG.ConnectivityToQuantumState(node_vector, adjacency_matrix)\n",
    "print(quantum_state)\n",
    "node_vector, adjacency_matrix = QG.QuantumStateToConnectivity(quantum_state)\n",
    "print(\"node_vector\", node_vector)\n",
    "print(\"adjacency_matrix\")\n",
    "print(adjacency_matrix)\n",
    "print(QG.ConnectivityToSmiles(node_vector, adjacency_matrix))\n",
    "all_quantum_states = QG.enumerate_all_quantum_states(smiles)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N=C[C@@]1(O)O[C@@H]1CO\n"
     ]
    }
   ],
   "source": [
    "node_vector =       [2, 1, 1, 1, 3, 2, 1, 2, 0,]\n",
    "adjacency_matrix = [[0, 1, 1, 0, 0, 0, 0, 0, 0],\n",
    "                    [1, 0, 1, 0, 0, 0, 1, 0, 0],\n",
    "                    [1, 1, 0, 1, 0, 1, 0, 0, 0],\n",
    "                    [0, 0, 1, 0, 2, 0, 0, 0, 0],\n",
    "                    [0, 0, 0, 2, 0, 0, 0, 0, 0],\n",
    "                    [0, 0, 1, 0, 0, 0, 0, 0, 0],\n",
    "                    [0, 1, 0, 0, 0, 0, 0, 1, 0],\n",
    "                    [0, 0, 0, 0, 0, 0, 1, 0, 0],\n",
    "                    [0, 0, 0, 0, 0, 0, 0, 0, 0]]\n",
    "\n",
    "print(QG.ConnectivityToSmiles(node_vector, adjacency_matrix))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CC.CO\n"
     ]
    }
   ],
   "source": [
    "adjacency_matrix[1,2] = 0\n",
    "adjacency_matrix[2,1] = 0\n",
    "adjacency_matrix\n",
    "print(QG.ConnectivityToSmiles(node_vector, adjacency_matrix))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4, 3]\n",
      "[3, 2, 4, 1]\n",
      "mapping_num_2_molIdx {'1': 0, '2': 1, '3': 2, '4': 3, '5': 4}\n",
      "[2, 3, 4, 5] [3, 2, 1, 4] ['[OH:2]', '[NH2:3]', '[CH3:4]', '[Cl:5]']\n",
      "False\n",
      "[C@:1]([OH:2])([NH2:3])([CH3:4])[Cl:5]\n"
     ]
    }
   ],
   "source": [
    "def rank_list(lst):\n",
    "    sorted_list = sorted(enumerate(lst), key=lambda x: x[1])\n",
    "    rank = [0] * len(lst)\n",
    "    for i, (original_index, _) in enumerate(sorted_list):\n",
    "        rank[original_index] = i + 1\n",
    "    return rank\n",
    "\n",
    "def can_sort_with_even_swaps(list1, list2):\n",
    "    def count_inversions(lst):\n",
    "        inversions = 0\n",
    "        for i in range(len(lst)):\n",
    "            for j in range(i + 1, len(lst)):\n",
    "                if lst[i] > lst[j]:\n",
    "                    inversions += 1\n",
    "        return inversions\n",
    "    inversions_list1 = count_inversions(list1)\n",
    "    inversions_list2 = count_inversions(list2)\n",
    "    return (inversions_list1 - inversions_list2) % 2 == 0\n",
    "\n",
    "A = rank_list([2, 3, 5, 4])\n",
    "B = rank_list([3, 2, 4, 1])\n",
    "print(A)\n",
    "print(B)\n",
    "can_sort_with_even_swaps(A, B)\n",
    "\n",
    "test_smiles = \"[C:1]([OH:2])([NH2:3])([CH3:4])[Cl:5]\"\n",
    "mol = Chem.MolFromSmiles(test_smiles)\n",
    "mapping_num_2_molIdx = {}\n",
    "for atom in mol.GetAtoms():\n",
    "    mapping_num_2_molIdx.update({atom.GetProp('molAtomMapNumber'): atom.GetIdx()})\n",
    "\n",
    "print(\"mapping_num_2_molIdx\", mapping_num_2_molIdx)\n",
    "\n",
    "for atom in mol.GetAtoms():\n",
    "    if atom.GetPropsAsDict(True, False).get(\"_ChiralityPossible\", 0):\n",
    "        atom_map_list = [int(neighbor.GetProp('molAtomMapNumber')) for neighbor in atom.GetNeighbors()]\n",
    "        CIP_list = [int(neighbor.GetProp('_CIPRank')) for neighbor in atom.GetNeighbors()]\n",
    "        atom_type_list = [neighbor.GetSmarts() for neighbor in atom.GetNeighbors()]\n",
    "        print(atom_map_list, CIP_list, atom_type_list)\n",
    "        chiral_tag = can_sort_with_even_swaps(rank_list(atom_map_list), rank_list(CIP_list))\n",
    "        print(chiral_tag)\n",
    "        if chiral_tag:\n",
    "            atom.SetChiralTag(Chem.rdchem.ChiralType.CHI_TETRAHEDRAL_CW)\n",
    "        else:\n",
    "            atom.SetChiralTag(Chem.rdchem.ChiralType.CHI_TETRAHEDRAL_CCW)\n",
    "Chem.SanitizeMol(mol)\n",
    "print(Chem.MolToSmiles(mol))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[CH3:1][C@H:2]([OH:3])[NH2:4]\n",
      "[CH3:1][C@H:2]([NH2:3])[OH:4]\n"
     ]
    }
   ],
   "source": [
    "QG = MoleculeQuantumStateGenerator(9)\n",
    "test_smiles_1 = \"[CH:2]([OH:3])([NH2:4])([CH3:1])\"\n",
    "mol_1 = Chem.MolFromSmiles(test_smiles_1)\n",
    "QG._set_chiral_atom(mol_1)\n",
    "print(Chem.MolToSmiles(mol_1))\n",
    "test_smiles_1 = \"[CH:2]([OH:4])([NH2:3])([CH3:1])\"\n",
    "mol_1 = Chem.MolFromSmiles(test_smiles_1)\n",
    "QG._set_chiral_atom(mol_1)\n",
    "print(Chem.MolToSmiles(mol_1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "mol = QG._set_chiral_atom(mol_1)\n",
    "mol"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "STEREOANY\n",
      "[OH:1][CH:4]=[CH:2][Cl:3]\n",
      "[1]\n",
      "[3]\n",
      "[OH:1]/[CH:4]=[CH:2]/[Cl:3]\n"
     ]
    }
   ],
   "source": [
    "def rank_list(lst):\n",
    "    sorted_list = sorted(enumerate(lst), key=lambda x: x[1])\n",
    "    rank = [0] * len(lst)\n",
    "    for i, (original_index, _) in enumerate(sorted_list):\n",
    "        rank[original_index] = i + 1\n",
    "    return rank\n",
    "\n",
    "def can_sort_with_even_swaps(list1, list2):\n",
    "    def count_inversions(lst):\n",
    "        inversions = 0\n",
    "        for i in range(len(lst)):\n",
    "            for j in range(i + 1, len(lst)):\n",
    "                if lst[i] > lst[j]:\n",
    "                    inversions += 1\n",
    "        return inversions\n",
    "    inversions_list1 = count_inversions(list1)\n",
    "    inversions_list2 = count_inversions(list2)\n",
    "    return (inversions_list1 - inversions_list2) % 2 == 0\n",
    "\n",
    "def determine_bond_stereo(bond):\n",
    "    begin_atom = bond.GetBeginAtom()\n",
    "    begin_atom_map_number = int(begin_atom.GetProp('molAtomMapNumber'))\n",
    "    end_atom = bond.GetEndAtom()\n",
    "    end_atom_map_number = int(end_atom.GetProp('molAtomMapNumber'))\n",
    "    begin_atom_neighbor_map = [int(a.GetProp('molAtomMapNumber')) for a in begin_atom.GetNeighbors()]\n",
    "    begin_atom_neighbor_map.remove(end_atom_map_number)\n",
    "    print(begin_atom_neighbor_map)\n",
    "    end_atom_neighbor_map = [int(a.GetProp('molAtomMapNumber')) for a in end_atom.GetNeighbors()]\n",
    "    end_atom_neighbor_map.remove(begin_atom_map_number)\n",
    "    print(end_atom_neighbor_map)\n",
    "    if (len(begin_atom_neighbor_map) == 1) and (len(end_atom_neighbor_map) == 1):\n",
    "        if abs(begin_atom_neighbor_map[0] - begin_atom_map_number) == abs(end_atom_neighbor_map[0] - end_atom_map_number):\n",
    "            bond.SetStereo(Chem.rdchem.BondStereo.STEREOZ)\n",
    "        else:\n",
    "            bond.SetStereo(Chem.rdchem.BondStereo.STEREOE)\n",
    "    else:\n",
    "        begin_CIP_list = [int(neighbor.GetProp('_CIPRank')) for neighbor in begin_atom.GetNeighbors() \n",
    "                          if int(neighbor.GetProp('molAtomMapNumber')) != end_atom_map_number]\n",
    "        print(begin_CIP_list)\n",
    "        end_CIP_list = [int(neighbor.GetProp('_CIPRank')) for neighbor in end_atom.GetNeighbors()\n",
    "                          if int(neighbor.GetProp('molAtomMapNumber')) != begin_atom_map_number]\n",
    "        print(end_CIP_list)\n",
    "        if can_sort_with_even_swaps(rank_list(begin_atom_neighbor_map), rank_list(begin_CIP_list)) == \\\n",
    "            can_sort_with_even_swaps(rank_list(end_atom_neighbor_map), rank_list(end_CIP_list)):\n",
    "            bond.SetStereo(Chem.rdchem.BondStereo.STEREOZ)\n",
    "        else:\n",
    "            bond.SetStereo(Chem.rdchem.BondStereo.STEREOE)\n",
    "    return\n",
    "\n",
    "def _set_bond_stereo(mol):\n",
    "    Chem.FindPotentialStereoBonds(mol,cleanIt=True)\n",
    "    for bond in mol.GetBonds():\n",
    "        if bond.GetStereo() == Chem.rdchem.BondStereo.STEREOANY:\n",
    "            determine_bond_stereo(bond)\n",
    "    return\n",
    "\n",
    "# test_smiles = \"[C:1]([OH:2])([NH2:3])=[CH:4][Cl:5]\"\n",
    "test_smiles = \"[CH:4]([OH:1])=[CH:2][Cl:3]\"\n",
    "mol = Chem.MolFromSmiles(test_smiles)\n",
    "mapping_num_2_molIdx = {}\n",
    "for atom in mol.GetAtoms():\n",
    "    mapping_num_2_molIdx.update({atom.GetProp('molAtomMapNumber'): atom.GetIdx()})\n",
    "\n",
    "Chem.FindPotentialStereoBonds(mol,cleanIt=True)\n",
    "for bond in mol.GetBonds():\n",
    "    if bond.GetStereo() == Chem.rdchem.BondStereo.STEREOANY:\n",
    "        # bond.SetStereo(Chem.rdchem.BondStereo.STEREOE)\n",
    "        print(bond.GetStereo())\n",
    "        break\n",
    "# Chem.AssignStereochemistry(mol, flagPossibleStereoCenters=True, force=True)\n",
    "print(Chem.MolToSmiles(mol, True))\n",
    "\n",
    "determine_bond_stereo(bond)\n",
    "print(Chem.MolToSmiles(mol, True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 0\n",
      "1 3 1\n",
      "1 4 2\n",
      "4 5 3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'[C:1](\\\\[OH:2])([NH2:3])=[CH:4]/[Cl:5]'"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = Chem.MolFromSmiles(\"[C:1]([OH:2])([NH2:3])=[CH:4][Cl:5]\")\n",
    "for bond in m.GetBonds():\n",
    "    print(bond.GetBeginAtom().GetProp('molAtomMapNumber'), bond.GetEndAtom().GetProp('molAtomMapNumber'), bond.GetIdx())\n",
    "m.GetBondWithIdx(0).SetBondDir(Chem.BondDir.ENDUPRIGHT) # ENDDOWNRIGHT\n",
    "m.GetBondWithIdx(1).SetBondDir(Chem.BondDir.ENDDOWNRIGHT)\n",
    "m.GetBondWithIdx(3).SetBondDir(Chem.BondDir.ENDDOWNRIGHT) # ENDUPRIGHT\n",
    "Chem.AssignStereochemistry(m,force=True)\n",
    "Chem.MolToSmiles(m, canonical=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                         ┌───┐                               \n",
      "q_0: ────────────────────┤ X ├──────■────────────────────────\n",
      "     ┌──────────┐        └─┬─┘      │             ┌───┐┌─┐   \n",
      "q_1: ┤ Ry(5π/8) ├──■───────■────────┼─────────────┤ X ├┤M├───\n",
      "     └──┬───┬───┘┌─┴─┐┌──────────┐┌─┴─┐┌─────────┐└─┬─┘└╥┘┌─┐\n",
      "q_2: ───┤ X ├────┤ X ├┤ Ry(-π/4) ├┤ X ├┤ Ry(π/4) ├──■───╫─┤M├\n",
      "        └───┘    └───┘└──────────┘└───┘└─────────┘      ║ └╥┘\n",
      "c: 2/═══════════════════════════════════════════════════╩══╩═\n",
      "                                                        0  1 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_755846/4142234065.py:40: DeprecationWarning: The 'qiskit.Aer' entry point is deprecated and will be removed in Qiskit 1.0. You should use 'qiskit_aer.Aer' directly instead.\n",
      "  simulator = Aer.get_backend('qasm_simulator')\n",
      "/tmp/ipykernel_755846/4142234065.py:43: DeprecationWarning: The function ``qiskit.execute_function.execute()`` is deprecated as of qiskit 0.46.0. It will be removed in the Qiskit 1.0 release. This function combines ``transpile`` and ``backend.run``, which is covered by ``Sampler`` :mod:`~qiskit.primitives`. Alternatively, you can also run :func:`.transpile` followed by ``backend.run()``.\n",
      "  results = execute(qc, backend=simulator, shots=1024).result()\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x500 with 1 Axes>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit import QuantumCircuit, Aer, transpile, assemble, execute\n",
    "from qiskit.visualization import plot_histogram\n",
    "import numpy as np\n",
    "\n",
    "def controlled_hadamard(qc, control, target):\n",
    "    # Apply H to target if control is |1>\n",
    "    qc.ry(-np.pi/4, target)\n",
    "    qc.cx(control, target)\n",
    "    qc.ry(np.pi/4, target)\n",
    "\n",
    "def controlled_ry(qc, control, target, digit):\n",
    "    # Apply H to target if control is |1>\n",
    "    qc.ry(-np.pi/2 * digit, target)\n",
    "    qc.cx(control, target)\n",
    "    qc.ry(np.pi/2 * digit, target)\n",
    "\n",
    "# 创建一个有三个量子位的量子电路\n",
    "qc = QuantumCircuit(3, 2)\n",
    "\n",
    "# 对第一个量子位应用 Hadamard 门\n",
    "# qc.h(1)\n",
    "qc.ry(np.pi / 2 * 1.25, 1)\n",
    "qc.x(2)\n",
    "\n",
    "# 使用 CNOT 门，控制量子位是第一个量子位，目标量子位是第二个量子位\n",
    "qc.cx(1, 2)\n",
    "\n",
    "qc.cx(1, 0)\n",
    "\n",
    "controlled_hadamard(qc, 0, 2)\n",
    "qc.cx(2, 1)\n",
    "\n",
    "# 测量所有量子位\n",
    "qc.measure([1,2], [0,1])\n",
    "\n",
    "# 绘制量子电路\n",
    "print(qc.draw())\n",
    "\n",
    "# 执行量子电路\n",
    "simulator = Aer.get_backend('qasm_simulator')\n",
    "compiled_circuit = transpile(qc, simulator)\n",
    "qobj = assemble(compiled_circuit)\n",
    "results = execute(qc, backend=simulator, shots=1024).result()\n",
    "counts = results.get_counts(qc)\n",
    "\n",
    "# 绘制直方图\n",
    "plot_histogram(counts)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     ┌───┐                                     \n",
      "q_0: ┤ X ├──■────────────────────────■─────────\n",
      "     └───┘┌─┴─┐                 ┌────┴─────┐┌─┐\n",
      "q_1: ─────┤ X ├──■───────■──────┤ Ry(π/20) ├┤M├\n",
      "          └───┘┌─┴─┐┌────┴─────┐└───┬─┬────┘└╥┘\n",
      "q_2: ──────────┤ X ├┤ Ry(π/20) ├────┤M├──────╫─\n",
      "               └───┘└──────────┘    └╥┘      ║ \n",
      "c: 2/════════════════════════════════╩═══════╩═\n",
      "                                     1       0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_755846/940388544.py:39: DeprecationWarning: The function ``qiskit.execute_function.execute()`` is deprecated as of qiskit 0.46.0. It will be removed in the Qiskit 1.0 release. This function combines ``transpile`` and ``backend.run``, which is covered by ``Sampler`` :mod:`~qiskit.primitives`. Alternatively, you can also run :func:`.transpile` followed by ``backend.run()``.\n",
      "  results = execute(qc, backend=simulator, shots=1024).result()\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x500 with 1 Axes>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit import QuantumCircuit, Aer, transpile, assemble, execute\n",
    "from qiskit.visualization import plot_histogram\n",
    "import numpy as np\n",
    "\n",
    "def controlled_hadamard(qc, control, target):\n",
    "    # Apply H to target if control is |1>\n",
    "    qc.ry(-np.pi/4, target)\n",
    "    qc.cx(control, target)\n",
    "    qc.ry(np.pi/4, target)\n",
    "\n",
    "def controlled_ry(qc, control, target, digit):\n",
    "    # Apply H to target if control is |1>\n",
    "    qc.ry(np.pi/2 * digit, target)\n",
    "    qc.cx(control, target)\n",
    "    qc.ry(-np.pi/2 * digit, target)\n",
    "\n",
    "# 创建一个有三个量子位的量子电路\n",
    "qc = QuantumCircuit(3, 2)\n",
    "\n",
    "# 对第一个量子位应用 Hadamard 门\n",
    "qc.x(0)\n",
    "qc.cx(0,1)\n",
    "qc.cx(1,2)\n",
    "qc.cry(np.pi*0.05, 1,2,)\n",
    "qc.cry(np.pi*0.05, 0,1,)\n",
    "# controlled_ry(qc, 1, 2, 0.05)\n",
    "# controlled_ry(qc, 0, 1, 0.05)\n",
    "\n",
    "# 测量所有量子位\n",
    "qc.measure([1,2], [0,1])\n",
    "\n",
    "# 绘制量子电路\n",
    "print(qc.draw())\n",
    "\n",
    "# 执行量子电路\n",
    "simulator = Aer.get_backend('qasm_simulator')\n",
    "compiled_circuit = transpile(qc, simulator)\n",
    "qobj = assemble(compiled_circuit)\n",
    "results = execute(qc, backend=simulator, shots=1024).result()\n",
    "counts = results.get_counts(qc)\n",
    "\n",
    "# 绘制直方图\n",
    "plot_histogram(counts)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     ┌───┐                  \n",
      "q_0: ┤ X ├──────────────────\n",
      "     ├───┤┌──────────┐┌─┐   \n",
      "q_1: ┤ X ├┤ Ry(π/20) ├┤M├───\n",
      "     ├───┤├──────────┤└╥┘┌─┐\n",
      "q_2: ┤ X ├┤ Ry(π/20) ├─╫─┤M├\n",
      "     └───┘└──────────┘ ║ └╥┘\n",
      "c: 2/══════════════════╩══╩═\n",
      "                       0  1 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_755846/3734957549.py:39: DeprecationWarning: The function ``qiskit.execute_function.execute()`` is deprecated as of qiskit 0.46.0. It will be removed in the Qiskit 1.0 release. This function combines ``transpile`` and ``backend.run``, which is covered by ``Sampler`` :mod:`~qiskit.primitives`. Alternatively, you can also run :func:`.transpile` followed by ``backend.run()``.\n",
      "  results = execute(qc, backend=simulator, shots=1024).result()\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x500 with 1 Axes>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit import QuantumCircuit, Aer, transpile, assemble, execute\n",
    "from qiskit.visualization import plot_histogram\n",
    "import numpy as np\n",
    "\n",
    "def controlled_hadamard(qc, control, target):\n",
    "    # Apply H to target if control is |1>\n",
    "    qc.ry(-np.pi/4, target)\n",
    "    qc.cx(control, target)\n",
    "    qc.ry(np.pi/4, target)\n",
    "\n",
    "def controlled_ry(qc, control, target, digit):\n",
    "    # Apply H to target if control is |1>\n",
    "    qc.ry(-np.pi/2 * digit, target)\n",
    "    qc.cx(control, target)\n",
    "    qc.ry(np.pi/2 * digit, target)\n",
    "\n",
    "# 创建一个有三个量子位的量子电路\n",
    "qc = QuantumCircuit(3, 2)\n",
    "\n",
    "# 对第一个量子位应用 Hadamard 门\n",
    "qc.x(0)\n",
    "qc.x(1)\n",
    "qc.x(2)\n",
    "\n",
    "qc.ry(np.pi*0.05, 1)\n",
    "qc.ry(np.pi*0.05, 2)\n",
    "# controlled_ry(qc, 0, 1, 0.05)\n",
    "\n",
    "# 测量所有量子位\n",
    "qc.measure([1,2], [0,1])\n",
    "\n",
    "# 绘制量子电路\n",
    "print(qc.draw())\n",
    "\n",
    "# 执行量子电路\n",
    "simulator = Aer.get_backend('qasm_simulator')\n",
    "compiled_circuit = transpile(qc, simulator)\n",
    "qobj = assemble(compiled_circuit)\n",
    "results = execute(qc, backend=simulator, shots=1024).result()\n",
    "counts = results.get_counts(qc)\n",
    "\n",
    "# 绘制直方图\n",
    "plot_histogram(counts)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_3948229/1570109299.py:52: DeprecationWarning: The 'qiskit.Aer' entry point is deprecated and will be removed in Qiskit 1.0. You should use 'qiskit_aer.Aer' directly instead.\n",
      "  simulator = Aer.get_backend('qasm_simulator')\n",
      "/tmp/ipykernel_3948229/1570109299.py:55: DeprecationWarning: The function ``qiskit.execute_function.execute()`` is deprecated as of qiskit 0.46.0. It will be removed in the Qiskit 1.0 release. This function combines ``transpile`` and ``backend.run``, which is covered by ``Sampler`` :mod:`~qiskit.primitives`. Alternatively, you can also run :func:`.transpile` followed by ``backend.run()``.\n",
      "  results = execute(qc, backend=simulator, shots=4096*4*4).result()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "39\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x500 with 1 Axes>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit import QuantumCircuit, Aer, transpile, assemble, execute\n",
    "from qiskit.visualization import plot_histogram\n",
    "import numpy as np\n",
    "import random\n",
    "\n",
    "def controlled_ry(qc, control, target, digit):\n",
    "    # Apply H to target if control is |1>\n",
    "    qc.ry(-np.pi/2 * digit, target)\n",
    "    qc.cx(control, target)\n",
    "    qc.ry(np.pi/2 * digit, target)\n",
    "\n",
    "# 创建一个有三个量子位的量子电路\n",
    "qc = QuantumCircuit(5+3, 4+2)\n",
    "\n",
    "# qc.h(1)\n",
    "# qc.ry(np.pi / 2 , 1)\n",
    "qc.ry(np.pi / 2 * 1.25, 1)\n",
    "qc.x(2)\n",
    "\n",
    "qc.cx(1, 2)\n",
    "qc.cx(1, 0)\n",
    "\n",
    "qc.ch(0,2)\n",
    "qc.cx(2, 1)\n",
    "\n",
    "qc.ry(np.pi  * 0.5 , 3)\n",
    "qc.ry(np.pi  * 0.5, 4)\n",
    "# controlled_ry(qc, 4, 3, random.random())\n",
    "controlled_ry(qc, 0, 3, 0.9)\n",
    "qc.cx(3, 4)\n",
    "\n",
    "qc.x(3)\n",
    "qc.x(4)\n",
    "qc.x(5)\n",
    "qc.ccx(3,4,5)\n",
    "qc.x(3)\n",
    "qc.x(4)\n",
    "\n",
    "controlled_ry(qc, 5, 6, 0.51)\n",
    "# controlled_hadamard(qc, 5, 6)\n",
    "controlled_ry(qc, 6, 7, 0.3)\n",
    "# controlled_hadamard(qc, 5, 7)\n",
    "controlled_ry(qc, 5, 7, 0.8)\n",
    "# 测量所有量子位\n",
    "qc.measure([1,2,3,4,6,7], [0,1,2,3,4,5])\n",
    "\n",
    "# 绘制量子电路\n",
    "# print(qc.draw())\n",
    "\n",
    "\n",
    "# 执行量子电路\n",
    "simulator = Aer.get_backend('qasm_simulator')\n",
    "compiled_circuit = transpile(qc, simulator)\n",
    "qobj = assemble(compiled_circuit)\n",
    "results = execute(qc, backend=simulator, shots=4096*4*4).result()\n",
    "counts = results.get_counts(qc)\n",
    "\n",
    "print(len(counts))\n",
    "# 绘制直方图\n",
    "plot_histogram(counts)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/beegfs/home/lungyi45/.conda/envs/qmg/lib/python3.10/site-packages/qiskit/visualization/circuit/matplotlib.py:266: FutureWarning: The default matplotlib drawer scheme will be changed to \"iqp\" in a following release. To silence this warning, specify the current default explicitly as style=\"clifford\", or the new default as style=\"iqp\".\n",
      "  self._style, def_font_ratio = load_style(self._style)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2043.33x785.944 with 1 Axes>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17\n"
     ]
    }
   ],
   "source": [
    "print(qc.depth())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "362880\n",
      "362880\n",
      "['011100011001011001000000000100000000010000000010000000000000000001010001000001000000000000', '100100010101101101010000000000000000000100000100000000000000000100000000000000010000000110', '100101000110110101010000000000000100000000100000000000000001000000000000000100000100010000', '010001100101011110000001000001010000000000000000000000001001000000000001000001000000000000', '101001010001011101000000000001000000010000000001000000000001000000100000000000010000010000', '010101010110001110000000000100100000000101000000010000000101000000000000000000000000000000', '110110000101100101010000000000100000000100010000000001000100000000000000000000000001000000', '010101101110000101000101000000000000000101000001000000000000000000010000001000000000000000', '011001010111011000000000000001000000000000010000000100000000001000010000000100010000000000', '100001101101010101000000000001000000000000000000011000000000000000000100010000010000000001', '100101011001110001010001000000000000000001000000000000000001000010000000000001000000000100', '100010010111010101000000010000000100000000000000000000000100000000000110000000000100010000', '100101110110010100010000000000000000010100000000000000010000000000100000000000010100000000', '010111100110010100000000010000000000000000010000000000011000010000010000000000010000000000', '100100110101100101000000000100000000000100000000000000000000000100100000010000000001010000', '100101011001000111010000000000000000000000000101010000000000010000000001000000000010000000', '110101100101011000100000010000000000000000000100000001000100010000000000010000000000000000', '010111010110100001001000000100000000010000000000000100000000000100000000010001000000000000', '110101010110100001000001100000000000010000000000000001000001000001000001000000000000000000', '011000011001010111000000000100000000000001000100000000000000000001000000010000000000000110', '010110010010011101010000000000000001000000000000000000010000000100010100000000000000100000', '010100100101111001000000000100000000000000100100000000000000000100000000000101010000000000', '010110100111010001000100000001000001000010000000000000000000010000000001000001000000000000', '010001110110011001000100000100000000000000000000000000000000010000001000010100000001000000', '100100011101100101010000000100000000001000000000000000000000000100000000000100000000010001', '010110010110010011010000000100000100000000000000010000010000010000000000000000000000001000', '010111100101100001000100010001000010010000000000000000000000000100000000000000000001000000', '011101100101000110000000000000010000001000000100000001000000010100000000000000000000000001', '101001010101110001000100000000000100000100000000000000100000000000000101010000000000000000', '001010010111010101000000000000000000000000010001000100000000000000000101000100100000000000', '011011010101011000000000010000010000000001000000100001000000000000010000000000010000000000', '111000011001010101000000001000000100000000000001000000000000000000000101010000000000010000', '001101010110010110000000000000000001000000100000010001000000000000000000000100000000000101', '010001100111011001000000001000010000000000000000000100000000000000000100000100000001000100', '000101011010011101000000000000000000000001000001010100000100000000000000000000010000100000', '101100010101010110000000000100000000001001000000000000000000000000010100000001010000000000', '010001100110110101000001000000010000000000000000010000100000000000000000000001000001000100', '010001011001110110000001000000000000000000000000000000000100010001000000000000100001000001', '010001100101011011000000010000000000000000000000000001000100010000000000000001000000011000', '000101101001011101000000000000000000000000000001010001000100000000000000010001000000100000', '110101100110010001000100000000001000000100000000010000010000000000000001000000000001000000', '011101010110100001000100000000000001100000000000000001000000000001000000010001000000000000', '001001100101011101000000000000000001000000010000000000000001010000000001000100000000100000', '000110010110011101000000000000000001000000000001000100000000000001000000001000010000010000', '111010010101010100000000011000000000000100000000010001000000000000010000010000000000000000', '010001011011010110000000010101000000000000000000000010000001000000010100000000000000000000', '100001010101011110000100000001000000000000000000000000001000010000010100000000010000000000', '100101110101000110010000000000000000010000000100000100000000001000000000000001000001000000', '100101010110110001000100000000000100010000000000000100000000000101000000000000000000001000', '100100010110010111010000000001000000000000000010000000000000000001000000000100000100000001', '010110000101110110000000010000000100000000100001000001000000000000000000000000010100000000', '010101100111010010010000000100000100000000000000010000010000010000000010000000000000000000', '101001010101010011000001000001000000000001000000000000010000000000001001000000000001000000', '100101010110001101000101000000000000000100000000000000000001000000100001000100000000000000', '011001110001011001010001000001000000000000000000100000000100000000000000000000000001000001', '011101010001011010010000000001010000000010000000010000000001000000000000000000000001000000', '001001010111011001000000000000000001000000000000000101000000001000010000000000000000000101', '010101100111000110000000000000010100000100000000000010000001010000000001000000000000000000', '011010010100110101000101000000000000000000000100000100000000000000000000100000000000010001', '101101011000010101000100000000000001000000000010010000000000000000000000010001000000010000', '000111011001011001000000000000000010000100000000000000010000010100000000000000000000010100', '100101010110000111000001010000000000000001000101010000000000000000000000000010000000000000', '110100011001100101100000000100000000000100000000000000000000000100000000000001010000000001', '011000110110010101010010000000000000000000000100000000000000000001000000010000010000000001', '000101100101011110000000000000000000010001000000000100000101000001000000000000000000100000', '010110010100011011000100000000001000000100000000000100000000000001000000000000000000010100', '000101101001010111000000000000000000000000010000000000000100000000010001010000000010000001', '011101010100101001000100000000000000100100000000000000010000000001000000000101000000000000', '010101110001100110010000000000000000000000010000010001000001000000100000000000000000010000', '101001011101010001000001000000000100000000010000000000010000000100000000010010000000000000', '000110110101100101000000000000000000000100000000000000000100001000010000010000010000000001', '010001010110011011000000010000000000000000000000000001000010000101000000000101000000000000', '010100011101011010000001000000000000000000010000000000000000010000010010000000000001000100', '010101110001100110000010000000000100000001000000000000000100000100000000000000010000000001', '011101010110000110100000000100000001000000000000000100000001000100010000000000000000000000', '010101101101010010000100000000000000001000000001010100000000000000000000000000010001000000', '100101100101110001010100000000000000000000100000000000000001000100000001000000010000000000', '010110111000010101000001010000000101000000010000000000000100000000100000000000000000000000', '010011100101010110000000010000000100000000000000000001100000000100000000000000000100000100', '100101011001001101010000000000000001000000000100000000000000010100000000000001000000000010', '011100010110011001100000000000010000000100000000000000000000010000000001000000000000000101', '010111000101011010000000000100000110000000000001000000010000000000000000010000000000010000', '010111001010010101000000000100000101000100010000000000001000000000000000000000000100000000', '011011000110010101000000000100000100000100000000000100001000000000000000010000000100000000', '010111010001101001000101000001000010000000000100000000000000000000000000000000000101000000', '011010010101011100010000010000010000000000000000010001000000000001000000000000001000000000', '011110010001011001000000000000010100000010010000000000010000000001000000000000000100000000', '100101100111000101000100010000000000010001000001000010000000000000000000000100000000000000', '110010010110010101000000000001001000000000000000000000010000010000000001000000000001010000', '010011100101010110001001000000000000000000000000000001000000000001000000010000000101000000', '101100010101100101000000000000000100001000000001000000000000000000010000010000000001010000', '000111010110010110000000000000000000000100000000000100001000000101000000000001000100000000', '000111100101011001000000000000000000000000000001000110000000000100000100010100000000000000', '100100110101011001010000000001000000000100000000000000000000000110000000000000000101000000', '010101101101100001000000100001000000000000000001010101000000000000000000000000000000000100', '010110000111100101000000000000000100000100010000000000000001000000000000000000001001010000', '011001011100010110000001000000000100000000000100000000000100000000000000100100000000000100', '100100101101010101010000000000010000000000010000000000000000000100000001001000000001000000', '010110011100011001000100100000000000010000000000010000000000000000000000010000000000010100', '010101010010101101000000000000000100000000011000010000010000000000000000000000000001000001']\n"
     ]
    }
   ],
   "source": [
    "print(len(all_quantum_states))\n",
    "print(len(set((all_quantum_states))))\n",
    "print(all_quantum_states[:100])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "smiles_list = [QG.QuantumStateToSmiles(q) for q in all_quantum_states]\n",
    "print(len(set(smiles_list)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['010000001000010101000000000000010100000000000000000000000000000000000000010000000000010000',\n",
       " '000001100001010001000000000000000000000000000000000000010001000001000000000000000001000000',\n",
       " '000000100100010101000000000000000000000000000000000000000000000000010000010000000000000101',\n",
       " '010101000100000010000100010000000000000100000000000000000001000000000000000000000000000000',\n",
       " '000101010000100001000000000000000000000000000001010000010000000000000100000000000000000000',\n",
       " '000001010010010001000000000000000000000000000000000000010001000001000000000000000001000000',\n",
       " '010001100001000100000100000000000000000000000000000000000100000100000000000000000100000000',\n",
       " '000000010001010110000000000000000000000000000000000000000000000000010000000000010001010000',\n",
       " '010101000000001001010100000000000000000000000001000000000100000000000000000000000000000000',\n",
       " '000001010101000010000000000000000000000000000000000001000001010000000001000000000000000000']"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_quantum_states[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "90"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(QG.ConnectivityToQuantumState(node_vector, adjacency_matrix))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 1. 3. 2. 3. 2. 1. 0.]\n",
      "[[0. 1. 0. 0. 0. 0. 0. 0.]\n",
      " [1. 0. 2. 0. 0. 0. 0. 0.]\n",
      " [0. 2. 0. 1. 0. 0. 0. 0.]\n",
      " [0. 0. 1. 0. 1. 0. 0. 0.]\n",
      " [0. 0. 0. 1. 0. 1. 1. 0.]\n",
      " [0. 0. 0. 0. 1. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 1. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0.]]\n",
      "[0. 1. 1. 3. 3. 1. 2. 2.]\n",
      "[[0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 1. 0. 0.]\n",
      " [0. 0. 0. 0. 1. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 2. 1. 0.]\n",
      " [0. 0. 1. 0. 0. 0. 1. 1.]\n",
      " [0. 1. 0. 2. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 1. 1. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 1. 0. 0. 0.]]\n",
      "CC=NON(C)O\n",
      "CC=NON(C)O\n",
      "010111101110010001000000000000100000000000010000000001000000010100000000\n",
      "000101111101101000000000000000000000010000000100000000100100000101000000\n"
     ]
    }
   ],
   "source": [
    "print(node_vector)\n",
    "print(adjacency_matrix)\n",
    "new_index = (1, 5, 3, 6, 4, 7, 2)\n",
    "mapping_dict = {old: new for old, new in enumerate(new_index)}\n",
    "\n",
    "new_node_vector = np.zeros(8)\n",
    "new_adjacency_matrix = np.zeros((8,8))\n",
    "# atom\n",
    "for old, new in mapping_dict.items():\n",
    "    new_node_vector[new] = node_vector[old]\n",
    "# bond\n",
    "for ix, row in enumerate(adjacency_matrix):\n",
    "    for iy_, bond_type_idx in enumerate(row[ix+1:]):\n",
    "        if not bond_type_idx:\n",
    "            continue\n",
    "        iy = ix + iy_ + 1\n",
    "        ix_new = mapping_dict[ix]\n",
    "        iy_new = mapping_dict[iy]\n",
    "        new_adjacency_matrix[ix_new][iy_new] = bond_type_idx\n",
    "        new_adjacency_matrix[iy_new][ix_new] = bond_type_idx\n",
    "print(new_node_vector)\n",
    "print(new_adjacency_matrix)\n",
    "\n",
    "print(QG.ConnectivityToSmiles(node_vector, adjacency_matrix))\n",
    "print(QG.ConnectivityToSmiles(new_node_vector, new_adjacency_matrix))\n",
    "print(QG.ConnectivityToQuantumState(node_vector, adjacency_matrix))\n",
    "print(QG.ConnectivityToQuantumState(new_node_vector, new_adjacency_matrix))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "362880"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "node_indices = np.arange(len(node_vector))\n",
    "perms = list(permutations(node_indices))\n",
    "len(perms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 2, 3), (1, 2, 4), (1, 2, 5), (1, 2, 6), (1, 2, 7), (1, 2, 8), (1, 3, 2), (1, 3, 4), (1, 3, 5), (1, 3, 6), (1, 3, 7), (1, 3, 8), (1, 4, 2), (1, 4, 3), (1, 4, 5), (1, 4, 6), (1, 4, 7), (1, 4, 8), (1, 5, 2), (1, 5, 3), (1, 5, 4), (1, 5, 6), (1, 5, 7), (1, 5, 8), (1, 6, 2), (1, 6, 3), (1, 6, 4), (1, 6, 5), (1, 6, 7), (1, 6, 8), (1, 7, 2), (1, 7, 3), (1, 7, 4), (1, 7, 5), (1, 7, 6), (1, 7, 8), (1, 8, 2), (1, 8, 3), (1, 8, 4), (1, 8, 5), (1, 8, 6), (1, 8, 7), (2, 1, 3), (2, 1, 4), (2, 1, 5), (2, 1, 6), (2, 1, 7), (2, 1, 8), (2, 3, 1), (2, 3, 4), (2, 3, 5), (2, 3, 6), (2, 3, 7), (2, 3, 8), (2, 4, 1), (2, 4, 3), (2, 4, 5), (2, 4, 6), (2, 4, 7), (2, 4, 8), (2, 5, 1), (2, 5, 3), (2, 5, 4), (2, 5, 6), (2, 5, 7), (2, 5, 8), (2, 6, 1), (2, 6, 3), (2, 6, 4), (2, 6, 5), (2, 6, 7), (2, 6, 8), (2, 7, 1), (2, 7, 3), (2, 7, 4), (2, 7, 5), (2, 7, 6), (2, 7, 8), (2, 8, 1), (2, 8, 3), (2, 8, 4), (2, 8, 5), (2, 8, 6), (2, 8, 7), (3, 1, 2), (3, 1, 4), (3, 1, 5), (3, 1, 6), (3, 1, 7), (3, 1, 8), (3, 2, 1), (3, 2, 4), (3, 2, 5), (3, 2, 6), (3, 2, 7), (3, 2, 8), (3, 4, 1), (3, 4, 2), (3, 4, 5), (3, 4, 6), (3, 4, 7), (3, 4, 8), (3, 5, 1), (3, 5, 2), (3, 5, 4), (3, 5, 6), (3, 5, 7), (3, 5, 8), (3, 6, 1), (3, 6, 2), (3, 6, 4), (3, 6, 5), (3, 6, 7), (3, 6, 8), (3, 7, 1), (3, 7, 2), (3, 7, 4), (3, 7, 5), (3, 7, 6), (3, 7, 8), (3, 8, 1), (3, 8, 2), (3, 8, 4), (3, 8, 5), (3, 8, 6), (3, 8, 7), (4, 1, 2), (4, 1, 3), (4, 1, 5), (4, 1, 6), (4, 1, 7), (4, 1, 8), (4, 2, 1), (4, 2, 3), (4, 2, 5), (4, 2, 6), (4, 2, 7), (4, 2, 8), (4, 3, 1), (4, 3, 2), (4, 3, 5), (4, 3, 6), (4, 3, 7), (4, 3, 8), (4, 5, 1), (4, 5, 2), (4, 5, 3), (4, 5, 6), (4, 5, 7), (4, 5, 8), (4, 6, 1), (4, 6, 2), (4, 6, 3), (4, 6, 5), (4, 6, 7), (4, 6, 8), (4, 7, 1), (4, 7, 2), (4, 7, 3), (4, 7, 5), (4, 7, 6), (4, 7, 8), (4, 8, 1), (4, 8, 2), (4, 8, 3), (4, 8, 5), (4, 8, 6), (4, 8, 7), (5, 1, 2), (5, 1, 3), (5, 1, 4), (5, 1, 6), (5, 1, 7), (5, 1, 8), (5, 2, 1), (5, 2, 3), (5, 2, 4), (5, 2, 6), (5, 2, 7), (5, 2, 8), (5, 3, 1), (5, 3, 2), (5, 3, 4), (5, 3, 6), (5, 3, 7), (5, 3, 8), (5, 4, 1), (5, 4, 2), (5, 4, 3), (5, 4, 6), (5, 4, 7), (5, 4, 8), (5, 6, 1), (5, 6, 2), (5, 6, 3), (5, 6, 4), (5, 6, 7), (5, 6, 8), (5, 7, 1), (5, 7, 2), (5, 7, 3), (5, 7, 4), (5, 7, 6), (5, 7, 8), (5, 8, 1), (5, 8, 2), (5, 8, 3), (5, 8, 4), (5, 8, 6), (5, 8, 7), (6, 1, 2), (6, 1, 3), (6, 1, 4), (6, 1, 5), (6, 1, 7), (6, 1, 8), (6, 2, 1), (6, 2, 3), (6, 2, 4), (6, 2, 5), (6, 2, 7), (6, 2, 8), (6, 3, 1), (6, 3, 2), (6, 3, 4), (6, 3, 5), (6, 3, 7), (6, 3, 8), (6, 4, 1), (6, 4, 2), (6, 4, 3), (6, 4, 5), (6, 4, 7), (6, 4, 8), (6, 5, 1), (6, 5, 2), (6, 5, 3), (6, 5, 4), (6, 5, 7), (6, 5, 8), (6, 7, 1), (6, 7, 2), (6, 7, 3), (6, 7, 4), (6, 7, 5), (6, 7, 8), (6, 8, 1), (6, 8, 2), (6, 8, 3), (6, 8, 4), (6, 8, 5), (6, 8, 7), (7, 1, 2), (7, 1, 3), (7, 1, 4), (7, 1, 5), (7, 1, 6), (7, 1, 8), (7, 2, 1), (7, 2, 3), (7, 2, 4), (7, 2, 5), (7, 2, 6), (7, 2, 8), (7, 3, 1), (7, 3, 2), (7, 3, 4), (7, 3, 5), (7, 3, 6), (7, 3, 8), (7, 4, 1), (7, 4, 2), (7, 4, 3), (7, 4, 5), (7, 4, 6), (7, 4, 8), (7, 5, 1), (7, 5, 2), (7, 5, 3), (7, 5, 4), (7, 5, 6), (7, 5, 8), (7, 6, 1), (7, 6, 2), (7, 6, 3), (7, 6, 4), (7, 6, 5), (7, 6, 8), (7, 8, 1), (7, 8, 2), (7, 8, 3), (7, 8, 4), (7, 8, 5), (7, 8, 6), (8, 1, 2), (8, 1, 3), (8, 1, 4), (8, 1, 5), (8, 1, 6), (8, 1, 7), (8, 2, 1), (8, 2, 3), (8, 2, 4), (8, 2, 5), (8, 2, 6), (8, 2, 7), (8, 3, 1), (8, 3, 2), (8, 3, 4), (8, 3, 5), (8, 3, 6), (8, 3, 7), (8, 4, 1), (8, 4, 2), (8, 4, 3), (8, 4, 5), (8, 4, 6), (8, 4, 7), (8, 5, 1), (8, 5, 2), (8, 5, 3), (8, 5, 4), (8, 5, 6), (8, 5, 7), (8, 6, 1), (8, 6, 2), (8, 6, 3), (8, 6, 4), (8, 6, 5), (8, 6, 7), (8, 7, 1), (8, 7, 2), (8, 7, 3), (8, 7, 4), (8, 7, 5), (8, 7, 6)]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "# Example usage\n",
    "elements = [1, 2, 3, 4, 5, 6, 7, 8]\n",
    "k = 3\n",
    "permutations = generate_permutations(elements, k)\n",
    "print(permutations)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1\n",
      "0 2\n",
      "0 3\n",
      "0 4\n",
      "1 2\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "node_vector = np.array([1, 0, 0, 0, 3.])\n",
    "adjacency_matrix = np.array([[0, 0, 0, 0, 0.],\n",
    "                             [0, 0, 1, 0, 0.],\n",
    "                             [0, 0, 0, 0, 0.],\n",
    "                             [0, 0, 0, 0, 0.],\n",
    "                             [0, 0, 0, 0, 0.]])\n",
    "print(ConnectivityToSmiles(node_vector, adjacency_matrix))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "CCNC=O\n"
     ]
    }
   ],
   "source": [
    "smiles = \"CCNC=O\"\n",
    "mol = Chem.MolFromSmiles(smiles)\n",
    "for i, atom in enumerate(mol.GetAtoms()):\n",
    "    print(atom.GetIdx())\n",
    "    # print(atom.GetSymbol())\n",
    "    # atom.SetAtomMapNum(i)\n",
    "    # print(atom.GetAtomMapNum())\n",
    "    # print(atom.Get)\n",
    "    # print(bond.GetBondType())\n",
    "print(Chem.MolToSmiles(mol))\n",
    "for i, atom in enumerate(mol.GetAtoms()):\n",
    "    print(atom.GetIdx())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'11'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def decimal_to_binary(x, padd_length=1):\n",
    "    \"\"\"\n",
    "    Parameters:\n",
    "    x (int): The decimal value.\n",
    "\n",
    "    Returns:\n",
    "    str: A binary bit string.\n",
    "    \"\"\"\n",
    "    bit = \"0\"*padd_length + bin(x)[2:]\n",
    "    return bit[-2:]\n",
    "\n",
    "decimal_to_binary(3)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
